以下整理了一些我當初在學習的時候整理的Ruby陣列相關方法

• list.sum : 總和
  list.[-1] : 陣列最後一個

  list = [1, 2, 3]
  puts list.sum                      
  #=> 6
  
  puts list.[-1]
  # 3
  

• list.length : 陣列長度

  heroes = ['孫悟空', '魯夫', '宇智波佐助', '⼀拳超人', '流川楓', '⿊崎一護', '劍⼼'];
  puts heroes.length # 印出 7
  

• list.map{|x| x*2} : 對集合裡的每個元素進行運算，並收集成一個新的集合 (=collect)
  list.map.with_index { |x, i| x * i } : 有需要用到index的話後面要加上.with_index

  list = [1, 2, 3, 4, 5]
  p list.map {|x| x*2} # 變數 x 只有在 Block 裡有效，會產生 [2, 4, 6, 8, 10]
  

  p (1..10).map {|x| x*2} 
  

• list.filter {|x| x.odd? } : 挑選符合條件的元素成為一個新的陣列 (同意詞:filter) (反意詞:reject)
  = list.select {|x| x.odd? }

  • odd?：檢查數值是否為奇數。
  • even?：檢查數值是否為偶數。

  list = [1, 2, 3, 4, 5]
  
  p list.select {|x| x.odd?} 
  

with_index

1. each_with_index: 使用迭代方法逐個取得陣列元素及其索引。

   array.each_with_index do |element, index|
     # 使用 element 和 index 做些事情
   end
   

2. map.with_index: 與 map 方法類似，但同時也提供索引值。

   new_array = array.map.with_index do |element, index|
     # 使用 element 和 index 產生新的值
   end
   

3. select.with_index: 與 select 方法類似，但同時也提供索引值，用於選擇滿足特定條件的元素。

   
   new_array = array.select.with_index do |element, index|
     # 使用 element 和 index 檢查條件
   end
   

• list.sum : 陣列總和
  ⇒ list.reduce{|sum,x| sum+x} : 陣列總和

list = [1, 2, 3, 4, 5]

p list.reduce{|sum,x| sum+x}
p list.sum

• list.first : 回傳第一個元素

list = [1, 3, 4, 1, 7, nil, 7]
p list.first. #1

• list.compact : 去除nil

list = [1, 3, 4, 1, 7, nil, 7]
p list.compact

• list.uniq : 去除重複的數字

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]

• list.delete(”element”) : 刪除陣列中的某個值

a = [ "a", "b", "b", "b", "c" ]
a.delete("b")          #=> "b"
a                      #=> ["a", "c"]

• list.sort : 把陣列的數字從小排到大:

  list = [3, 1, 7, 4]
  p list.sort [1, 3, 4, 7]
  

  • list.sort : 進⾏排序，但不會改變 list 的內容

    list.sort! : 進⾏排序，並且直接改變 list 的內容

    list = [9, 5, 2, 7]
    p list.sort  # [2, 5, 7, 9]
    p list       # [9, 5, 2, 7]
    
    p list.sort! # [2, 5, 7, 9]
    p list       # [2, 5, 7, 9]
    

• list.sort_by : 按照字串長度作排序

  language = ['PHP', 'Python', 'Ruby', 'Perl', 'ASP', 'Objective-C', 'Swift', 'Kotlin', 'Go']
  p language.sort_by {|lang| lang.length}
  
  # ["Go", "PHP", "ASP", "Ruby", "Perl", "Swift", "Python", "Kotlin", "Objective-C"]
  

• list.include? : 檢查陣列是否含有某個元素

  ['Cat', 'Dog', 'Bird'].include? 'Dog'
  => true
  

• push：向陣列末尾添加一個或多個元素。

  array = [1, 2, 3]
  array.push(4)
  
  # array: [1, 2, 3, 4]
  
  

• pop：刪除並返回陣列的最後一個元素。

  array = [1, 2, 3]
  last_element = array.pop
  
  # array: [1, 2]
  # last_element: 3
  
  

• unshift：向陣列開頭添加一個或多個元素。

  array = [2, 3, 4]
  array.unshift(1)
  
  # array: [1, 2, 3, 4]
  
  

• shift：刪除並返回陣列的第一個元素。

  array = [1, 2, 3]
  first_element = array.shift
  
  # array: [2, 3]
  # first_element: 1
  
  

• length 或 size：獲取陣列的長度（元素的數量）。

  array = [1, 2, 3, 4, 5]
  length = array.length
  
  # length: 5
  
  

• include?：檢查陣列是否包含指定的元素。

  array = [1, 2, 3]
  includes_2 = array.include?(2)
  
  # includes_2: true
  
  

• join：將陣列的元素連接成一個字符串，使用指定的分隔符。
  回傳字串

  array = [1, 2, 3]
  result = array.join('-')
  
  # result: "1-2-3"
  
  

• sort：對陣列的元素進行排序。

  array = [3, 1, 2]
  sorted_array = array.sort
  
  # sorted_array: [1, 2, 3]
  
  

• reverse：反轉陣列的元素順序。

  rubyCopy code
  array = [1, 2, 3]
  reversed_array = array.reverse
  
  # reversed_array: [3, 2, 1]
  
  

• each：對陣列的每個元素進行迭代，執行指定的操作。

  array = [1, 2, 3]
  array.each do |element|
    puts element
  end
  
  # 輸出結果：
  # 1
  # 2
  # 3
  
  

• list.max : 找出list最大元素
  list.min : 找出list最小元素

  arr = [5, 2, 9, 1, 7]
  max_element = arr.max
  
  puts max_element
  
  arr = [5, 2, 9, 1, 7]
  
  min_element = arr.min
  
  puts min_element
  

• list.index() : 找出某個數的索引值

  arr = [5, 2, 9, 1, 7, 3]
  
  puts arr.max
  #9
  
  puts arr.index(arr.max)
  # 2
  

• list.max_by : 給定規則，找出陣列中具有最大值的元素
  list.min_by : 給定規則，找出陣列中具有最小值的元素

  arr = ["apple", "banana", "cherry", "date"]
  
  # 找出長度最長的字串
  longest_string = arr.max_by { |item| item.length }
  puts longest_string
  
  # 找出長度最短的字串
  shortest_string = arr.min_by { |item| item.length }
  puts shortest_string
  

陣列相加相減

chars1 = ["a", "b", "c", "d", "f", "g"];
chars2 = ["a", "b", "c", "d"];

 p (chars1+chars2)
["a", "b", "c", "d", "f", "g", "a", "b", "c", "d"]

 p (chars1-chars2)
["f", "g"]

隨機

1. list.sample 從陣列或範圍中隨機選擇一個元素
   list.sample(3)從陣列中隨機選擇 3 個元素
   如果是範圍的話就要轉成陣列再用

   array = [1, 2, 3, 4, 5]
   p array.sample
   
   p(1..100).to_a.sample(5)
   
   

2. list.shuffle list洗牌
   list.first(num) 回傳最前面的某幾個值

   p(1..100).to_a.shuffle.first(5)
   p(1..100).to_a.sample(5)
   
   #to_a 轉成陣列
   #shuffle 洗牌
   #first 返回最前面的element
   

3. rand

   1. 生成 0 到 1 之間的隨機浮點數：

      random_float = rand
      puts random_float
      

   2. 生成指定範圍內的隨機整數：

      random_integer = rand(1..100)  # 生成 1 到 100 之間的隨機整數
      puts random_integer
      

   3. 生成指定範圍內的隨機浮點數：

      random_float = rand(0.0..10.0)  # 生成 0 到 10 之間的隨機浮點數
      puts random_float
      

引數相關

• args.length 或 args.size 方法來獲取引數的數量
  *args 作為方法的參數時，所有傳遞給該方法的引數都將被收集到一個陣列中。(args 只是一個變數名稱)

  def print_arguments(*args)
    puts "引數的數量：#{args.length}"
    puts "引數的數量：#{args.size}"
  end
  
  print_arguments(1, 2, 3)
  # 輸出結果：
  # 引數的數量：3
  # 引數的數量：3
  
  print_arguments("hello", "world")
  # 輸出結果：
  # 引數的數量：2
  # 引數的數量：2
  

陣列的部分就到這邊，我們明天繼續!